from utils import cache, db
from concurrent.futures import ThreadPoolExecutor

def db_queue_init():
    """
    1. 去数据库获取未执行的订单
    2. 去redis队列获取未执行的订单
    3. 将数据库中未执行的订单同步到redis队列
    """
    #1. 去数据库获取未执行的订单
    db_list = db.fetch_all("select id from `order` where status = 1", [])
    # db_list -> [{'id': 1}, {'id': 2}, {'id': 4}, {'id': 5}, {'id': 8}, {'id': 9} ]
    db_id_list = {item["id"] for item in db_list}
    
     #2. 去redis队列获取所有的订单
    cache_list = cache.fetch_all_queue()
    # cache_list -> [b'8', b'9', b'5', b'4', b'2', b'1']
    cache_int_list = {int(iten.decode("utf-8")) for iten in cache_list}
    
    #3. 找到数据库中未执行的订单，且不在redis队列中的所有订单ID ->更新放到redis队列中
    need_push = db_id_list - cache_int_list # 用到了集合的差集运算
    
    #4. 将这些订单ID压入redis队列
    if need_push:
        for id in need_push:
            cache.push_queque(id)  # 将每个订单ID压入队列
            
def task(info_dict):
    pass
    
        

def run():
    """从Redis队列中获取任务并执行"""
    
    #1. 初始化数据库未在队列中的订单
    db_queue_init()
    
    while True:
    #2. 从Redis队列中获取任务
        order_id = cache.pop_queque()
        print(f"获取到任务: {order_id}") #注意这里不能直接return，如果直接return会导致循环结束，只能执行一次任务
        if not order_id:
            print("没有任务，等待中...")
            continue
    
    #3. 订单是否存在
        order_dict = db.fetch_one("select * from `order` where id = %s", (order_id,))
        if not order_dict:
            print(f"订单 {order_id} 不存在，跳过处理")
            continue
        
    #4. 更新订单状态
        db.update("update `order` set status = %s where id = %s", [2, order_id])
    
    #5. 模拟执行任务
        print(f"正在执行订单 {order_id}...")
        thread_pool = ThreadPoolExecutor(30)
        for i in range(order_id['count']):
            thread_pool.submit(task, order_id)
        thread_pool.shutdown(wait=True)
        
    #6. 模拟任务执行完成
        db.update("update `order` set status = %s where id = %s", [3, order_id])
    
               
if __name__ == "__main__":
    print("Worker started, waiting for tasks...")
    run()
    print("Worker finished processing tasks.")
# 这里是一个简单的工作线程，持续从Redis队列中获取任务并执行
